home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / ftplib.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  18.7 KB  |  836 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import os
  5. import sys
  6.  
  7. try:
  8.     import SOCKS
  9.     socket = SOCKS
  10.     del SOCKS
  11.     from socket import getfqdn
  12.     socket.getfqdn = getfqdn
  13.     del getfqdn
  14. except ImportError:
  15.     import socket
  16.  
  17. __all__ = [
  18.     'FTP',
  19.     'Netrc']
  20. MSG_OOB = 1
  21. FTP_PORT = 21
  22.  
  23. class Error(Exception):
  24.     pass
  25.  
  26.  
  27. class error_reply(Error):
  28.     pass
  29.  
  30.  
  31. class error_temp(Error):
  32.     pass
  33.  
  34.  
  35. class error_perm(Error):
  36.     pass
  37.  
  38.  
  39. class error_proto(Error):
  40.     pass
  41.  
  42. all_errors = (Error, socket.error, IOError, EOFError)
  43. CRLF = '\r\n'
  44.  
  45. class FTP:
  46.     debugging = 0
  47.     host = ''
  48.     port = FTP_PORT
  49.     sock = None
  50.     file = None
  51.     welcome = None
  52.     passiveserver = 1
  53.     
  54.     def __init__(self, host = '', user = '', passwd = '', acct = ''):
  55.         if host:
  56.             self.connect(host)
  57.             if user:
  58.                 self.login(user, passwd, acct)
  59.             
  60.         
  61.  
  62.     
  63.     def connect(self, host = '', port = 0):
  64.         if host:
  65.             self.host = host
  66.         
  67.         if port:
  68.             self.port = port
  69.         
  70.         msg = 'getaddrinfo returns an empty list'
  71.         for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM):
  72.             (af, socktype, proto, canonname, sa) = res
  73.             
  74.             try:
  75.                 self.sock = socket.socket(af, socktype, proto)
  76.                 self.sock.connect(sa)
  77.             except socket.error:
  78.                 msg = None
  79.                 if self.sock:
  80.                     self.sock.close()
  81.                 
  82.                 self.sock = None
  83.                 continue
  84.  
  85.         
  86.         if not self.sock:
  87.             raise socket.error, msg
  88.         
  89.         self.af = af
  90.         self.file = self.sock.makefile('rb')
  91.         self.welcome = self.getresp()
  92.         return self.welcome
  93.  
  94.     
  95.     def getwelcome(self):
  96.         if self.debugging:
  97.             print '*welcome*', self.sanitize(self.welcome)
  98.         
  99.         return self.welcome
  100.  
  101.     
  102.     def set_debuglevel(self, level):
  103.         self.debugging = level
  104.  
  105.     debug = set_debuglevel
  106.     
  107.     def set_pasv(self, val):
  108.         self.passiveserver = val
  109.  
  110.     
  111.     def sanitize(self, s):
  112.         if s[:5] == 'pass ' or s[:5] == 'PASS ':
  113.             i = len(s)
  114.             while i > 5 and s[i - 1] in '\r\n':
  115.                 i = i - 1
  116.             s = s[:5] + '*' * (i - 5) + s[i:]
  117.         
  118.         return repr(s)
  119.  
  120.     
  121.     def putline(self, line):
  122.         line = line + CRLF
  123.         if self.debugging > 1:
  124.             print '*put*', self.sanitize(line)
  125.         
  126.         self.sock.sendall(line)
  127.  
  128.     
  129.     def putcmd(self, line):
  130.         if self.debugging:
  131.             print '*cmd*', self.sanitize(line)
  132.         
  133.         self.putline(line)
  134.  
  135.     
  136.     def getline(self):
  137.         line = self.file.readline()
  138.         if self.debugging > 1:
  139.             print '*get*', self.sanitize(line)
  140.         
  141.         if not line:
  142.             raise EOFError
  143.         
  144.         if line[-2:] == CRLF:
  145.             line = line[:-2]
  146.         elif line[-1:] in CRLF:
  147.             line = line[:-1]
  148.         
  149.         return line
  150.  
  151.     
  152.     def getmultiline(self):
  153.         line = self.getline()
  154.         if line[3:4] == '-':
  155.             code = line[:3]
  156.             while None:
  157.                 nextline = self.getline()
  158.                 line = line + '\n' + nextline
  159.                 if nextline[:3] == code and nextline[3:4] != '-':
  160.                     break
  161.                     continue
  162.                 continue
  163.         line[3:4] == '-'
  164.         return line
  165.  
  166.     
  167.     def getresp(self):
  168.         resp = self.getmultiline()
  169.         if self.debugging:
  170.             print '*resp*', self.sanitize(resp)
  171.         
  172.         self.lastresp = resp[:3]
  173.         c = resp[:1]
  174.         if c in ('1', '2', '3'):
  175.             return resp
  176.         
  177.         if c == '4':
  178.             raise error_temp, resp
  179.         
  180.         if c == '5':
  181.             raise error_perm, resp
  182.         
  183.         raise error_proto, resp
  184.  
  185.     
  186.     def voidresp(self):
  187.         resp = self.getresp()
  188.         if resp[0] != '2':
  189.             raise error_reply, resp
  190.         
  191.         return resp
  192.  
  193.     
  194.     def abort(self):
  195.         line = 'ABOR' + CRLF
  196.         if self.debugging > 1:
  197.             print '*put urgent*', self.sanitize(line)
  198.         
  199.         self.sock.sendall(line, MSG_OOB)
  200.         resp = self.getmultiline()
  201.         if resp[:3] not in ('426', '226'):
  202.             raise error_proto, resp
  203.         
  204.  
  205.     
  206.     def sendcmd(self, cmd):
  207.         self.putcmd(cmd)
  208.         return self.getresp()
  209.  
  210.     
  211.     def voidcmd(self, cmd):
  212.         self.putcmd(cmd)
  213.         return self.voidresp()
  214.  
  215.     
  216.     def sendport(self, host, port):
  217.         hbytes = host.split('.')
  218.         pbytes = [
  219.             repr(port / 256),
  220.             repr(port % 256)]
  221.         bytes = hbytes + pbytes
  222.         cmd = 'PORT ' + ','.join(bytes)
  223.         return self.voidcmd(cmd)
  224.  
  225.     
  226.     def sendeprt(self, host, port):
  227.         af = 0
  228.         if self.af == socket.AF_INET:
  229.             af = 1
  230.         
  231.         if self.af == socket.AF_INET6:
  232.             af = 2
  233.         
  234.         if af == 0:
  235.             raise error_proto, 'unsupported address family'
  236.         
  237.         fields = [
  238.             '',
  239.             repr(af),
  240.             host,
  241.             repr(port),
  242.             '']
  243.         cmd = 'EPRT ' + '|'.join(fields)
  244.         return self.voidcmd(cmd)
  245.  
  246.     
  247.     def makeport(self):
  248.         msg = 'getaddrinfo returns an empty list'
  249.         sock = None
  250.         for res in socket.getaddrinfo(None, 0, self.af, socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
  251.             (af, socktype, proto, canonname, sa) = res
  252.             
  253.             try:
  254.                 sock = socket.socket(af, socktype, proto)
  255.                 sock.bind(sa)
  256.             except socket.error:
  257.                 msg = None
  258.                 if sock:
  259.                     sock.close()
  260.                 
  261.                 sock = None
  262.                 continue
  263.  
  264.         
  265.         if not sock:
  266.             raise socket.error, msg
  267.         
  268.         sock.listen(1)
  269.         port = sock.getsockname()[1]
  270.         host = self.sock.getsockname()[0]
  271.         if self.af == socket.AF_INET:
  272.             resp = self.sendport(host, port)
  273.         else:
  274.             resp = self.sendeprt(host, port)
  275.         return sock
  276.  
  277.     
  278.     def makepasv(self):
  279.         if self.af == socket.AF_INET:
  280.             (host, port) = parse227(self.sendcmd('PASV'))
  281.         else:
  282.             (host, port) = parse229(self.sendcmd('EPSV'), self.sock.getpeername())
  283.         return (host, port)
  284.  
  285.     
  286.     def ntransfercmd(self, cmd, rest = None):
  287.         size = None
  288.         if self.passiveserver:
  289.             (host, port) = self.makepasv()
  290.             (af, socktype, proto, canon, sa) = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM)[0]
  291.             conn = socket.socket(af, socktype, proto)
  292.             conn.connect(sa)
  293.             if rest is not None:
  294.                 self.sendcmd('REST %s' % rest)
  295.             
  296.             resp = self.sendcmd(cmd)
  297.             if resp[0] == '2':
  298.                 resp = self.getresp()
  299.             
  300.             if resp[0] != '1':
  301.                 raise error_reply, resp
  302.             
  303.         else:
  304.             sock = self.makeport()
  305.             if rest is not None:
  306.                 self.sendcmd('REST %s' % rest)
  307.             
  308.             resp = self.sendcmd(cmd)
  309.             if resp[0] == '2':
  310.                 resp = self.getresp()
  311.             
  312.             if resp[0] != '1':
  313.                 raise error_reply, resp
  314.             
  315.             (conn, sockaddr) = sock.accept()
  316.         if resp[:3] == '150':
  317.             size = parse150(resp)
  318.         
  319.         return (conn, size)
  320.  
  321.     
  322.     def transfercmd(self, cmd, rest = None):
  323.         return self.ntransfercmd(cmd, rest)[0]
  324.  
  325.     
  326.     def login(self, user = '', passwd = '', acct = ''):
  327.         if not user:
  328.             user = 'anonymous'
  329.         
  330.         if not passwd:
  331.             passwd = ''
  332.         
  333.         if not acct:
  334.             acct = ''
  335.         
  336.         if user == 'anonymous' and passwd in ('', '-'):
  337.             passwd = passwd + 'anonymous@'
  338.         
  339.         resp = self.sendcmd('USER ' + user)
  340.         if resp[0] == '3':
  341.             resp = self.sendcmd('PASS ' + passwd)
  342.         
  343.         if resp[0] == '3':
  344.             resp = self.sendcmd('ACCT ' + acct)
  345.         
  346.         if resp[0] != '2':
  347.             raise error_reply, resp
  348.         
  349.         return resp
  350.  
  351.     
  352.     def retrbinary(self, cmd, callback, blocksize = 8192, rest = None):
  353.         self.voidcmd('TYPE I')
  354.         conn = self.transfercmd(cmd, rest)
  355.         while None:
  356.             data = conn.recv(blocksize)
  357.             if not data:
  358.                 break
  359.             
  360.             continue
  361.             conn.close()
  362.             return self.voidresp()
  363.  
  364.     
  365.     def retrlines(self, cmd, callback = None):
  366.         if callback is None:
  367.             callback = print_line
  368.         
  369.         resp = self.sendcmd('TYPE A')
  370.         conn = self.transfercmd(cmd)
  371.         fp = conn.makefile('rb')
  372.         while None:
  373.             line = fp.readline()
  374.             if self.debugging > 2:
  375.                 print '*retr*', repr(line)
  376.             
  377.             if not line:
  378.                 break
  379.             
  380.             if line[-2:] == CRLF:
  381.                 line = line[:-2]
  382.             elif line[-1:] == '\n':
  383.                 line = line[:-1]
  384.             
  385.             continue
  386.             fp.close()
  387.             conn.close()
  388.             return self.voidresp()
  389.  
  390.     
  391.     def storbinary(self, cmd, fp, blocksize = 8192):
  392.         self.voidcmd('TYPE I')
  393.         conn = self.transfercmd(cmd)
  394.         while None:
  395.             buf = fp.read(blocksize)
  396.             if not buf:
  397.                 break
  398.             
  399.             continue
  400.             conn.close()
  401.             return self.voidresp()
  402.  
  403.     
  404.     def storlines(self, cmd, fp):
  405.         self.voidcmd('TYPE A')
  406.         conn = self.transfercmd(cmd)
  407.         while None:
  408.             buf = fp.readline()
  409.             if not buf:
  410.                 break
  411.             
  412.             if buf[-2:] != CRLF:
  413.                 if buf[-1] in CRLF:
  414.                     buf = buf[:-1]
  415.                 
  416.                 buf = buf + CRLF
  417.             
  418.             continue
  419.             conn.close()
  420.             return self.voidresp()
  421.  
  422.     
  423.     def acct(self, password):
  424.         cmd = 'ACCT ' + password
  425.         return self.voidcmd(cmd)
  426.  
  427.     
  428.     def nlst(self, *args):
  429.         cmd = 'NLST'
  430.         for arg in args:
  431.             cmd = cmd + ' ' + arg
  432.         
  433.         files = []
  434.         self.retrlines(cmd, files.append)
  435.         return files
  436.  
  437.     
  438.     def dir(self, *args):
  439.         cmd = 'LIST'
  440.         func = None
  441.         if args[-1:] and type(args[-1]) != type(''):
  442.             args = args[:-1]
  443.             func = args[-1]
  444.         
  445.         for arg in args:
  446.             if arg:
  447.                 cmd = cmd + ' ' + arg
  448.                 continue
  449.         
  450.         self.retrlines(cmd, func)
  451.  
  452.     
  453.     def rename(self, fromname, toname):
  454.         resp = self.sendcmd('RNFR ' + fromname)
  455.         if resp[0] != '3':
  456.             raise error_reply, resp
  457.         
  458.         return self.voidcmd('RNTO ' + toname)
  459.  
  460.     
  461.     def delete(self, filename):
  462.         resp = self.sendcmd('DELE ' + filename)
  463.         if resp[:3] in ('250', '200'):
  464.             return resp
  465.         elif resp[:1] == '5':
  466.             raise error_perm, resp
  467.         else:
  468.             raise error_reply, resp
  469.  
  470.     
  471.     def cwd(self, dirname):
  472.         if dirname == '..':
  473.             
  474.             try:
  475.                 return self.voidcmd('CDUP')
  476.             except error_perm:
  477.                 msg = None
  478.                 if msg.args[0][:3] != '500':
  479.                     raise 
  480.                 
  481.             except:
  482.                 msg.args[0][:3] != '500'
  483.             
  484.  
  485.         None<EXCEPTION MATCH>error_perm
  486.         if dirname == '':
  487.             dirname = '.'
  488.         
  489.         cmd = 'CWD ' + dirname
  490.         return self.voidcmd(cmd)
  491.  
  492.     
  493.     def size(self, filename):
  494.         resp = self.sendcmd('SIZE ' + filename)
  495.         if resp[:3] == '213':
  496.             s = resp[3:].strip()
  497.             
  498.             try:
  499.                 return int(s)
  500.             except (OverflowError, ValueError):
  501.                 return long(s)
  502.             except:
  503.                 None<EXCEPTION MATCH>(OverflowError, ValueError)
  504.             
  505.  
  506.         None<EXCEPTION MATCH>(OverflowError, ValueError)
  507.  
  508.     
  509.     def mkd(self, dirname):
  510.         resp = self.sendcmd('MKD ' + dirname)
  511.         return parse257(resp)
  512.  
  513.     
  514.     def rmd(self, dirname):
  515.         return self.voidcmd('RMD ' + dirname)
  516.  
  517.     
  518.     def pwd(self):
  519.         resp = self.sendcmd('PWD')
  520.         return parse257(resp)
  521.  
  522.     
  523.     def quit(self):
  524.         resp = self.voidcmd('QUIT')
  525.         self.close()
  526.         return resp
  527.  
  528.     
  529.     def close(self):
  530.         if self.file:
  531.             self.file.close()
  532.             self.sock.close()
  533.             self.file = None
  534.             self.sock = None
  535.         
  536.  
  537.  
  538. _150_re = None
  539.  
  540. def parse150(resp):
  541.     global _150_re
  542.     if resp[:3] != '150':
  543.         raise error_reply, resp
  544.     
  545.     if _150_re is None:
  546.         import re
  547.         _150_re = re.compile('150 .* \\((\\d+) bytes\\)', re.IGNORECASE)
  548.     
  549.     m = _150_re.match(resp)
  550.     if not m:
  551.         return None
  552.     
  553.     s = m.group(1)
  554.     
  555.     try:
  556.         return int(s)
  557.     except (OverflowError, ValueError):
  558.         return long(s)
  559.  
  560.  
  561. _227_re = None
  562.  
  563. def parse227(resp):
  564.     global _227_re
  565.     if resp[:3] != '227':
  566.         raise error_reply, resp
  567.     
  568.     if _227_re is None:
  569.         import re
  570.         _227_re = re.compile('(\\d+),(\\d+),(\\d+),(\\d+),(\\d+),(\\d+)')
  571.     
  572.     m = _227_re.search(resp)
  573.     if not m:
  574.         raise error_proto, resp
  575.     
  576.     numbers = m.groups()
  577.     host = '.'.join(numbers[:4])
  578.     port = (int(numbers[4]) << 8) + int(numbers[5])
  579.     return (host, port)
  580.  
  581.  
  582. def parse229(resp, peer):
  583.     if resp[:3] != '229':
  584.         raise error_reply, resp
  585.     
  586.     left = resp.find('(')
  587.     if left < 0:
  588.         raise error_proto, resp
  589.     
  590.     right = resp.find(')', left + 1)
  591.     if right < 0:
  592.         raise error_proto, resp
  593.     
  594.     if resp[left + 1] != resp[right - 1]:
  595.         raise error_proto, resp
  596.     
  597.     parts = resp[left + 1:right].split(resp[left + 1])
  598.     if len(parts) != 5:
  599.         raise error_proto, resp
  600.     
  601.     host = peer[0]
  602.     port = int(parts[3])
  603.     return (host, port)
  604.  
  605.  
  606. def parse257(resp):
  607.     if resp[:3] != '257':
  608.         raise error_reply, resp
  609.     
  610.     if resp[3:5] != ' "':
  611.         return ''
  612.     
  613.     dirname = ''
  614.     i = 5
  615.     n = len(resp)
  616.     while i < n:
  617.         c = resp[i]
  618.         i = i + 1
  619.         if c == '"':
  620.             if i >= n or resp[i] != '"':
  621.                 break
  622.             
  623.             i = i + 1
  624.         
  625.         dirname = dirname + c
  626.     return dirname
  627.  
  628.  
  629. def print_line(line):
  630.     print line
  631.  
  632.  
  633. def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
  634.     if not targetname:
  635.         targetname = sourcename
  636.     
  637.     type = 'TYPE ' + type
  638.     source.voidcmd(type)
  639.     target.voidcmd(type)
  640.     (sourcehost, sourceport) = parse227(source.sendcmd('PASV'))
  641.     target.sendport(sourcehost, sourceport)
  642.     treply = target.sendcmd('STOR ' + targetname)
  643.     if treply[:3] not in ('125', '150'):
  644.         raise error_proto
  645.     
  646.     sreply = source.sendcmd('RETR ' + sourcename)
  647.     if sreply[:3] not in ('125', '150'):
  648.         raise error_proto
  649.     
  650.     source.voidresp()
  651.     target.voidresp()
  652.  
  653.  
  654. class Netrc:
  655.     __defuser = None
  656.     __defpasswd = None
  657.     __defacct = None
  658.     
  659.     def __init__(self, filename = None):
  660.         if filename is None:
  661.             if 'HOME' in os.environ:
  662.                 filename = os.path.join(os.environ['HOME'], '.netrc')
  663.             else:
  664.                 raise IOError, 'specify file to load or set $HOME'
  665.         
  666.         self._Netrc__hosts = { }
  667.         self._Netrc__macros = { }
  668.         fp = open(filename, 'r')
  669.         in_macro = 0
  670.         while None:
  671.             line = fp.readline()
  672.             if not line:
  673.                 break
  674.             
  675.             if in_macro and line.strip():
  676.                 macro_lines.append(line)
  677.                 continue
  678.             elif in_macro:
  679.                 self._Netrc__macros[macro_name] = tuple(macro_lines)
  680.                 in_macro = 0
  681.             
  682.             words = line.split()
  683.             host = None
  684.             user = None
  685.             passwd = None
  686.             acct = None
  687.             default = 0
  688.             i = 0
  689.             while i < len(words):
  690.                 w1 = words[i]
  691.                 if i + 1 < len(words):
  692.                     w2 = words[i + 1]
  693.                 else:
  694.                     w2 = None
  695.                 if w1 == 'default':
  696.                     default = 1
  697.                 elif w1 == 'machine' and w2:
  698.                     host = w2.lower()
  699.                     i = i + 1
  700.                 elif w1 == 'login' and w2:
  701.                     user = w2
  702.                     i = i + 1
  703.                 elif w1 == 'password' and w2:
  704.                     passwd = w2
  705.                     i = i + 1
  706.                 elif w1 == 'account' and w2:
  707.                     acct = w2
  708.                     i = i + 1
  709.                 elif w1 == 'macdef' and w2:
  710.                     macro_name = w2
  711.                     macro_lines = []
  712.                     in_macro = 1
  713.                     break
  714.                 
  715.                 i = i + 1
  716.             if default:
  717.                 if not user:
  718.                     pass
  719.                 self._Netrc__defuser = self._Netrc__defuser
  720.                 if not passwd:
  721.                     pass
  722.                 self._Netrc__defpasswd = self._Netrc__defpasswd
  723.                 if not acct:
  724.                     pass
  725.                 self._Netrc__defacct = self._Netrc__defacct
  726.             
  727.             if host:
  728.                 if host in self._Netrc__hosts:
  729.                     (ouser, opasswd, oacct) = self._Netrc__hosts[host]
  730.                     if not user:
  731.                         pass
  732.                     user = ouser
  733.                     if not passwd:
  734.                         pass
  735.                     passwd = opasswd
  736.                     if not acct:
  737.                         pass
  738.                     acct = oacct
  739.                 
  740.                 self._Netrc__hosts[host] = (user, passwd, acct)
  741.                 continue
  742.             continue
  743.             fp.close()
  744.             return None
  745.  
  746.     
  747.     def get_hosts(self):
  748.         return self._Netrc__hosts.keys()
  749.  
  750.     
  751.     def get_account(self, host):
  752.         host = host.lower()
  753.         user = None
  754.         passwd = None
  755.         acct = None
  756.         if host in self._Netrc__hosts:
  757.             (user, passwd, acct) = self._Netrc__hosts[host]
  758.         
  759.         if not user:
  760.             pass
  761.         user = self._Netrc__defuser
  762.         if not passwd:
  763.             pass
  764.         passwd = self._Netrc__defpasswd
  765.         if not acct:
  766.             pass
  767.         acct = self._Netrc__defacct
  768.         return (user, passwd, acct)
  769.  
  770.     
  771.     def get_macros(self):
  772.         return self._Netrc__macros.keys()
  773.  
  774.     
  775.     def get_macro(self, macro):
  776.         return self._Netrc__macros[macro]
  777.  
  778.  
  779.  
  780. def test():
  781.     if len(sys.argv) < 2:
  782.         print test.__doc__
  783.         sys.exit(0)
  784.     
  785.     debugging = 0
  786.     rcfile = None
  787.     while sys.argv[1] == '-d':
  788.         debugging = debugging + 1
  789.         del sys.argv[1]
  790.     if sys.argv[1][:2] == '-r':
  791.         rcfile = sys.argv[1][2:]
  792.         del sys.argv[1]
  793.     
  794.     host = sys.argv[1]
  795.     ftp = FTP(host)
  796.     ftp.set_debuglevel(debugging)
  797.     userid = passwd = acct = ''
  798.     
  799.     try:
  800.         netrc = Netrc(rcfile)
  801.     except IOError:
  802.         if rcfile is not None:
  803.             sys.stderr.write('Could not open account file -- using anonymous login.')
  804.         
  805.     except:
  806.         rcfile is not None
  807.  
  808.     
  809.     try:
  810.         (userid, passwd, acct) = netrc.get_account(host)
  811.     except KeyError:
  812.         sys.stderr.write('No account -- using anonymous login.')
  813.  
  814.     ftp.login(userid, passwd, acct)
  815.     for file in sys.argv[2:]:
  816.         if file[:2] == '-l':
  817.             ftp.dir(file[2:])
  818.             continue
  819.         if file[:2] == '-d':
  820.             cmd = 'CWD'
  821.             if file[2:]:
  822.                 cmd = cmd + ' ' + file[2:]
  823.             
  824.             resp = ftp.sendcmd(cmd)
  825.             continue
  826.         if file == '-p':
  827.             ftp.set_pasv(not (ftp.passiveserver))
  828.             continue
  829.         ftp.retrbinary('RETR ' + file, sys.stdout.write, 1024)
  830.     
  831.     ftp.quit()
  832.  
  833. if __name__ == '__main__':
  834.     test()
  835.  
  836.